package com.dianrui.firemenmonitor.util;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.os.Handler;
import android.os.Looper;
import android.support.v4.graphics.drawable.RoundedBitmapDrawable;
import android.support.v4.graphics.drawable.RoundedBitmapDrawableFactory;
import android.view.View;
import android.widget.ImageView;

import com.bumptech.glide.Glide;
import com.bumptech.glide.Priority;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.load.engine.cache.InternalCacheDiskCacheFactory;
import com.bumptech.glide.load.resource.drawable.GlideDrawable;
import com.bumptech.glide.request.RequestListener;
import com.bumptech.glide.request.target.BitmapImageViewTarget;
import com.bumptech.glide.request.target.SimpleTarget;
import com.dianrui.firemenmonitor.R;

import java.io.File;
import java.math.BigDecimal;


/**
 * Created by lzy on 2017/11/3.
 * 简单的Glide封装
 */
@SuppressWarnings("ALL")
public class GlideUtil {
    private volatile static GlideUtil instance;

    public static GlideUtil getInstance(){
        if (instance == null){
            synchronized (GlideUtil.class){
                if (instance == null){
                    instance = new GlideUtil();
                }
            }
        }
        return instance;
    }

    /**
     * Glide特点
     * 使用简单
     * 可配置度高，自适应程度高
     * 支持常见图片格式 Jpg png gif webp
     * 支持多种数据源  网络、本地、资源、Assets 等
     * 高效缓存策略    支持Memory和Disk图片缓存 默认Bitmap格式采用RGB_565内存使用至少减少一半
     * 生命周期集成   根据Activity/Fragment生命周期自动管理请求
     * 高效处理Bitmap  使用Bitmap Pool使Bitmap复用，主动调用recycle回收需要回收的Bitmap，减小系统回收压力
     * 这里默认支持Context，Glide支持Context,Activity,Fragment，FragmentActivity
     */

    //默认加载
    public static void loadImageView(Context mContext, String path, ImageView mImageView) {
        if (mContext != null) {
            Glide.with(mContext).load(path).diskCacheStrategy(DiskCacheStrategy.ALL).into(mImageView);
        }

    }

    //加载圆形图片
    public  static  void loadUserImageViewSize(final Context mContext, String path, final ImageView mImageView) {
        if (mContext != null) {
            Glide.with(mContext).load(path).asBitmap().placeholder(R.mipmap.ic_launcher).centerCrop().into(new BitmapImageViewTarget(mImageView){
                @Override
                protected void setResource(Bitmap resource) {
                    RoundedBitmapDrawable circularBitmapDrawable =
                            RoundedBitmapDrawableFactory.create(mContext.getResources(), resource);
                    circularBitmapDrawable.setCircular(true);
                    mImageView.setImageDrawable(circularBitmapDrawable);
                }
            });
        }
    }


    //设置动态GIF加载方式
    public static void loadGif(Context mContext, int Res, ImageView mImageView) {
        if (mContext != null) {
            Glide.with(mContext).load(Res).asGif().diskCacheStrategy(DiskCacheStrategy.SOURCE).into(mImageView);
        }
    }

    //设置静态GIF加载方式
    public static void loadImageViewStaticGif(Context mContext, String path, ImageView mImageView) {
        Glide.with(mContext).load(path).asBitmap().into(mImageView);
    }

    //设置监听的用处 可以用于监控请求发生错误来源，以及图片来源 是内存还是磁盘

    //设置监听请求接口
    public static void loadImageViewListener(Context mContext, String path, ImageView mImageView, RequestListener<String, GlideDrawable> requstlistener) {
        Glide.with(mContext).load(path).listener(requstlistener).into(mImageView);
    }


    //设置要加载的内容
    public  void loadImageViewContent(Context mContext, String path, SimpleTarget<GlideDrawable> simpleTarget) {
        Glide.with(mContext).load(path).centerCrop().into(simpleTarget);
    }

    /**
     * 加载本地资源图片
     *
     * @param isCircle
     * @param imageView
     * @param context
     * @param resourceId
     */
    public static ImageView glideLoad(boolean isCircle, final ImageView imageView, final Context context, int resourceId) {
        if (context == null) {
            return null;
        }
//        BitmapUtils.releaseImageViewResouce(imageViewResource);
        if (isCircle) {
            Glide.with(context)
                    .load((String) imageView.getTag(R.id.glide_tag))
                    .asBitmap()
                    .thumbnail(0.7f)//缩略图(先加载图片的百分之多少来显示，然后在加载原图)
//                    .centerCrop()//使用fitCenter即缩放图像让图像都测量出来等于或小于 ImageView 的边界范围,该图像将会完全显示，但可能不会填满整个*/
                    .skipMemoryCache(true)//跳过内存缓存
                    /*
                     *DiskCacheStrategy.NONE 什么都不缓存
                     *DiskCacheStrategy.SOURCE 仅仅只缓存原来的全分辨率的图像
                     *DiskCacheStrategy.RESULT 仅仅缓存最终的图像，即降低分辨率后的（或者是转换后的）
                     *DiskCacheStrategy.ALL 缓存所有版本的图像（默认行为）
                     * */
                    .diskCacheStrategy(DiskCacheStrategy.RESULT)
                    .priority(Priority.HIGH)//优先级，设置图片加载的顺序：
                    .into(new BitmapImageViewTarget(imageView) {
                        @Override
                        protected void setResource(Bitmap resource) {
                            RoundedBitmapDrawable circularBitmapDrawable =
                                    RoundedBitmapDrawableFactory.create(context.getResources(), resource);
                            circularBitmapDrawable.setCircular(true);
                            imageView.setImageDrawable(circularBitmapDrawable);
                        }
                    });
        } else {
            Glide
                    .with(context)
                    .load(resourceId)
                    .asBitmap()
                    .thumbnail(0.7f)//缩略图(先加载图片的百分之多少来显示，然后在加载原图)
//                    .centerCrop()//使用fitCenter即缩放图像让图像都测量出来等于或小于 ImageView 的边界范围,该图像将会完全显示，但可能不会填满整个*/
//                .dontAnimate()//不带动画
                    .skipMemoryCache(true)
                    .priority(Priority.HIGH)//优先级，设置图片加载的顺序：
                    .into(imageView);
        }

        return imageView;
    }

    //GLIDE框架下载图片
    public static ImageView downLoader(boolean isCircle, final ImageView imageView, final Context context) {
        if (context == null) {
            return null;
        }


        if (isCircle) {
//        BitmapUtils.releaseImageViewResouce(imageView);
            Glide.with(context)
                    .load((String) imageView.getTag(R.id.glide_tag))
                    .asBitmap()

                    .thumbnail(0.7f)//缩略图(先加载图片的百分之多少来显示，然后在加载原图)
                    //使用fitCenter即缩放图像让图像都测量出来等于或小于 ImageView 的边界范围,该图像将会完全显示，但可能不会填满整个*/
                    .skipMemoryCache(true)//跳过内存缓存
                    /*
                     *DiskCacheStrategy.NONE 什么都不缓存
                     *DiskCacheStrategy.SOURCE 仅仅只缓存原来的全分辨率的图像
                     *DiskCacheStrategy.RESULT 仅仅缓存最终的图像，即降低分辨率后的（或者是转换后的）
                     *DiskCacheStrategy.ALL 缓存所有版本的图像（默认行为）
                     * */
                    .diskCacheStrategy(DiskCacheStrategy.RESULT)
                    .priority(Priority.NORMAL)//优先级，设置图片加载的顺序：
                    .into(new BitmapImageViewTarget(imageView) {
                        @Override
                        protected void setResource(Bitmap resource) {
                            RoundedBitmapDrawable circularBitmapDrawable =
                                    RoundedBitmapDrawableFactory.create(context.getResources(), resource);
                            circularBitmapDrawable.setCircular(true);
                            imageView.setImageDrawable(circularBitmapDrawable);
                        }
                    });
        } else {
            //        BitmapUtils.releaseImageViewResouce(imageView);
            Glide.with(context.getApplicationContext())
                    .load((String) imageView.getTag(R.id.glide_tag))
                    .skipMemoryCache(true)//跳过内存缓存


                    /*
                     *DiskCacheStrategy.NONE 什么都不缓存
                     *DiskCacheStrategy.SOURCE 仅仅只缓存原来的全分辨率的图像
                     *DiskCacheStrategy.RESULT 仅仅缓存最终的图像，即降低分辨率后的（或者是转换后的）
                     *DiskCacheStrategy.ALL 缓存所有版本的图像（默认行为）
                     * */
                    .diskCacheStrategy(DiskCacheStrategy.RESULT)
                    .priority(Priority.NORMAL)//优先级，设置图片加载的顺序：
                    .into(imageView);
//                  .into(target);//我们通过网络得到的图片有的时候不一定就直接设置到ImageView上，有的时候就只是要一个Bitmap


        }

        return imageView;
    }

    /**
     * 清理视图内的图片
     *
     * @param view
     */
    public static void clearImg(View view) {
        if (view != null) {
            Glide.clear(view);
        }
    }

    //清理磁盘缓存
    public  void GuideClearDiskCache(Context mContext) {
        //理磁盘缓存 需要在子线程中执行
        Glide.get(mContext).clearDiskCache();
    }

    //清理内存缓存
    public  void GuideClearMemory(Context mContext) {
        //清理内存缓存  可以在UI主线程中进行
        Glide.get(mContext).clearMemory();
    }

    /**
     * 获取Glide造成的缓存大小
     *
     * @return CacheSize
     */
    public static String getCacheSize(Context context) {
        try {
            return getFormatSize(getFolderSize(new File(context.getCacheDir() + "/" + InternalCacheDiskCacheFactory.DEFAULT_DISK_CACHE_DIR)));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 获取指定文件夹内所有文件大小的和
     *
     * @param file file
     * @return size
     * @throws Exception
     */
    public static long getFolderSize(File file) throws Exception {
        long size = 0;
        try {
            File[] fileList = file.listFiles();
            for (File aFileList : fileList) {
                if (aFileList.isDirectory()) {
                    size = size + getFolderSize(aFileList);
                } else {
                    size = size + aFileList.length();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return size;
    }


    /**
     * 格式化单位
     *
     * @param size size
     * @return size
     */
    private static String getFormatSize(double size) {

        double kiloByte = size / 1024;
        if (kiloByte < 1) {
            return size + "Byte";
        }

        double megaByte = kiloByte / 1024;
        if (megaByte < 1) {
            BigDecimal result1 = new BigDecimal(Double.toString(kiloByte));
            return result1.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString() + "KB";
        }

        double gigaByte = megaByte / 1024;
        if (gigaByte < 1) {
            BigDecimal result2 = new BigDecimal(Double.toString(megaByte));
            return result2.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString() + "MB";
        }

        double teraBytes = gigaByte / 1024;
        if (teraBytes < 1) {
            BigDecimal result3 = new BigDecimal(Double.toString(gigaByte));
            return result3.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString() + "GB";
        }
        BigDecimal result4 = new BigDecimal(teraBytes);

        return result4.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString() + "TB";
    }


    /**
     * 清除图片磁盘缓存
     */
    public static void clearImageDiskCache(final Context context, final ClearListener clearListener) {
        try {
            if (Looper.myLooper() == Looper.getMainLooper()) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Glide.get(context).clearDiskCache();
                        Handler handler = new Handler(Looper.getMainLooper());
                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                if (clearListener != null) {
                                    clearListener.onSuccess();
                                }
                            }
                        });
                    }
                }).start();
            } else {
                Glide.get(context).clearDiskCache();
                Handler handler = new Handler(Looper.getMainLooper());
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        if (clearListener != null) {
                            clearListener.onSuccess();
                        }
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
            new Activity().runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    if (clearListener != null) {
                        clearListener.onFailure();
                    }
                }
            });
            Glide.get(context).clearDiskCache();
            Handler handler = new Handler(Looper.getMainLooper());
            handler.post(new Runnable() {
                @Override
                public void run() {
                    if (clearListener != null) {
                        clearListener.onFailure();
                    }
                }
            });

        }
    }

    public interface ClearListener {
        void onSuccess();

        void onFailure();
    }

}
